Merge upstream katef/libfsm code changes

Merge Upstream Code Changes: Amended FSM Makefile

Update for vmc codegen

This is a backport of katef#239 to the fastly private mirror for testing.

…-fastly-main

Add `extern` to ast expr tombstone fastly main

Update for ast rewriting

Merge katef/libfsm changes

Sync Fastly private mirror of libfsm with upstream (katef/libfsm)

…pstream

Sync fastly private mirror to upstream

…-usage-fix

Update fastly libfsm for memory usage fix

Update for missing <re/literal.h> header

Update for memcmp in vmc codegen

Update for <string.h> and re_is_literal() bugfixes

Update for strncmp in vmc codegen

Update for escaping ? to avoid emitting trigraphs

Update for disallowing \C

Sync performance improvements and misc. bugfixes from upstream

Update from upstream, including fixes for ITRK-1584

Upstream sync

Merge lx bugfix from upstream

Sync from upstream katef/libfsm main

When combining several unanchored regexes it becomes VERY expensive
to handle combinations of matches via the end state -- essentially,
the whole reachable DFA gets separate matching and non-matching copies
for each pattern, leading to a DFA whose size is proportional to the
number of *possible combinations* of matches. With eager outputs,
we can set a flag for matching as we reach the end of the original
pattern (before looping back and possibly also matching other patterns),
which keeps the state count from blowing up in fsm_determinise.

To see how much difference this makes, the test tests/eager_output/run7
combines 26 different patterns. It should finish very quickly (~50 msec,
just now). Try running it with `env FORCE_ENDIDS=N` for N increasing from
4 to 26. Around 10-11 it will start taking several seconds, and memory
usage will roughly double with each step.

This PR adds `fsm_union_repeated_pattern_group`, a variant of
`fsm_union_array` that combines a set of DFAs into a single NFA, but
correctly handles a mix of anchored and unanchored ends without the
state count blowing up. It currently needs flags passed in for each fsm
indicating whether the start and/or end are anchored, and there is a
hacky special case that removes self-edges from states with eager
outputs and instead connects them to a single overall unanchored end
loop. I haven't yet figured out how to handle this properly in the
general case, but it works for this specific use case, provided all the
DFAs are combined at once. (Combining multiple DFAs each produced by
determinising fsm_union_repeated_pattern_group's result probably won't
work correctly.) I have tried detecting and ignoring those edges in
fsm_determinise, after epsilon removal, but so far either it still
causes the graph size to blow up or subtly breaks something else.

This is still experimental, and the code generation for `-lc` here is
quite hacky -- it expects the caller to define a `FSM_SET_EAGER_OUTPUT`
acro, since the code generation interface doesn't define where the
match info will go yet. A later PR will add a new code generation mode
with better support for eager outputs, and I plan to eventually
integrate this better with rx, AMBIG_MULTIPLE, and so on.

(This squashes down a couple false starts.)

- Instead of taking an array of `struct fsm_union_array *` pointers,
  this now takes an array of `struct fsm *` pointers. The other
  fields on `fsm_union_array` are no longer used, so the extra
  struct layer has been removed.

- This now takes an extra argument, id_base, because each
  nfa[i] will get end IDs and/or output IDs (i + id_base) set on them.
  Previously these were set by the caller.

- Rename parameters, to emphasize that the FSMs must be NFAs.

- Update the test code for the interface changes.

- Remove flags from the test code that are no longer used.

There are two bugs captured in eager_output_unanchored_end_plus.c:

- Regexes ending in '+' weren't combining correctly, because analysis
  wasn't properly handling the construction for matching but optionally
  repeating the last character.

- Eager matching after consuming a single character from the start state
  wasn't linked correctly to the global_unanchored_start_loop, so while
  the labeled edges were copied the eager output was lost.

The other test files are focused on variants of that -- the + and
start cases individually, and when + precedes a `()` subtree with
more than one character.

Fuzzing has produced inputs that cause this to fail, but they
all depend on embedded '\0' characters. I wasn't able to reproduce
the failure without those present, but I will investigate further
later. For now, adding a TODO.

`(^|wax-)((?:banana|^apple))` is an example of a regex that needs
multiple anchored_start states linked in order to combine correctly.

Something strange is happening in CI, and these may be involved.

…eated_pattern_group

Fix anchoring for `fsm_union_repeated_pattern_group`

This reverts commit 6078cdf.

This is not the right place to do this, and this wasn't the actual
root cause of the CI failures.

CDATA codegen updates, part 3

Stray const in generated code

This had a lot of conflicts, because katef#513 cleaned up the eager output
code throughout.

…r-output

Upstream sync, mostly eager output interface cleanup

…erpolate-braces